home *** CD-ROM | disk | FTP | other *** search
/ Aminet 25 / Aminet 25 (1998)(GTI - Schatztruhe)[!][Jun 1998].iso / Aminet / game / shoot / ADoom_src_1_2.lha / ADoom_src / r_main.c < prev    next >
C/C++ Source or Header  |  1998-03-01  |  17KB  |  923 lines
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. //    Rendering main loop and setup functions,
  21. //     utility functions (BSP, geometry, trigonometry).
  22. //    See tables.c, too.
  23. //
  24. //-----------------------------------------------------------------------------
  25.  
  26.  
  27. static const char rcsid[] = "$Id: r_main.c,v 1.5 1997/02/03 22:45:12 b1 Exp $";
  28.  
  29.  
  30.  
  31. #include <stdlib.h>
  32. /* #include <math.h> */
  33.  
  34.  
  35. #include "doomdef.h"
  36. #include "doomstat.h"
  37. #include "d_net.h"
  38.  
  39. #include "m_bbox.h"
  40.  
  41. #include "r_local.h"
  42. #include "r_sky.h"
  43. #include "st_stuff.h"
  44.  
  45. extern int cpu_type;
  46.  
  47.  
  48.  
  49. // Fineangles in the SCREENWIDTH wide window.
  50. #define FIELDOFVIEW        2048    
  51.  
  52.  
  53.  
  54. int            viewangleoffset;
  55.  
  56. // increment every time a check is made
  57. int            validcount = 1;        
  58.  
  59.  
  60. lighttable_t*        fixedcolormap;
  61. extern lighttable_t**    walllights;
  62.  
  63. int            centerx;
  64. int            centery;
  65.  
  66. fixed_t            centerxfrac;
  67. fixed_t            centeryfrac;
  68. fixed_t            projection;
  69.  
  70. // just for profiling purposes
  71. int            framecount;    
  72.  
  73. int            sscount;
  74. int            linecount;
  75. int            loopcount;
  76.  
  77. fixed_t            viewx;
  78. fixed_t            viewy;
  79. fixed_t            viewz;
  80.  
  81. angle_t            viewangle;
  82.  
  83. fixed_t            viewcos;
  84. fixed_t            viewsin;
  85.  
  86. player_t*        viewplayer;
  87.  
  88. // 0 = high, 1 = low
  89. int            detailshift;    
  90.  
  91. //
  92. // precalculated math tables
  93. //
  94. angle_t            clipangle;
  95.  
  96. // The viewangletox[viewangle + FINEANGLES/4] lookup
  97. // maps the visible view angles to screen X coordinates,
  98. // flattening the arc to a flat projection plane.
  99. // There will be many angles mapped to the same X. 
  100. FAR int            viewangletox[FINEANGLES/2];
  101.  
  102. // The xtoviewangleangle[] table maps a screen pixel
  103. // to the lowest viewangle that maps back to x ranges
  104. // from clipangle to -clipangle.
  105. //angle_t            xtoviewangle[SCREENWIDTH+1];
  106. angle_t            *xtoviewangle;
  107.  
  108.  
  109. // UNUSED.
  110. // The finetangentgent[angle+FINEANGLES/4] table
  111. // holds the fixed_t tangent values for view angles,
  112. // ranging from MININT to 0 to MAXINT.
  113. // fixed_t        finetangent[FINEANGLES/2];
  114.  
  115. // fixed_t        finesine[5*FINEANGLES/4];
  116. fixed_t*        finecosine = &finesine[FINEANGLES/4];
  117.  
  118.  
  119. FAR lighttable_t*    scalelight[LIGHTLEVELS][MAXLIGHTSCALE];
  120. lighttable_t*        scalelightfixed[MAXLIGHTSCALE];
  121. FAR lighttable_t*    zlight[LIGHTLEVELS][MAXLIGHTZ];
  122.  
  123. // bumped light from gun blasts
  124. int            extralight;            
  125.  
  126.  
  127.  
  128. void (*colfunc) (void);
  129. void (*basecolfunc) (void);
  130. //#ifndef AMIGA
  131. void (*fuzzcolfunc) (void);
  132. void (*transcolfunc) (void);
  133. //#endif
  134. void (*spanfunc) (void);
  135.  
  136.  
  137.  
  138. //
  139. // R_AddPointToBox
  140. // Expand a given bbox
  141. // so that it encloses a given point.
  142. //
  143. void
  144. R_AddPointToBox
  145. ( int        x,
  146.   int        y,
  147.   fixed_t*    box )
  148. {
  149.     if (x< box[BOXLEFT])
  150.     box[BOXLEFT] = x;
  151.     if (x> box[BOXRIGHT])
  152.     box[BOXRIGHT] = x;
  153.     if (y< box[BOXBOTTOM])
  154.     box[BOXBOTTOM] = y;
  155.     if (y> box[BOXTOP])
  156.     box[BOXTOP] = y;
  157. }
  158.  
  159.  
  160. //
  161. // R_PointOnSide
  162. // Traverse BSP (sub) tree,
  163. //  check point against partition plane.
  164. // Returns side 0 (front) or 1 (back).
  165. //
  166. int
  167. R_PointOnSide
  168. ( fixed_t    x,
  169.   fixed_t    y,
  170.   node_t*    node )
  171. {
  172.     fixed_t    dx;
  173.     fixed_t    dy;
  174.     fixed_t    left;
  175.     fixed_t    right;
  176.     
  177.     if (!node->dx)
  178.     {
  179.     if (x <= node->x)
  180.         return node->dy > 0;
  181.     
  182.     return node->dy < 0;
  183.     }
  184.     if (!node->dy)
  185.     {
  186.     if (y <= node->y)
  187.         return node->dx < 0;
  188.     
  189.     return node->dx > 0;
  190.     }
  191.     
  192.     dx = (x - node->x);
  193.     dy = (y - node->y);
  194.     
  195.     // Try to quickly decide by looking at sign bits.
  196.     if ( (node->dy ^ node->dx ^ dx ^ dy)&0x80000000 )
  197.     {
  198.     if  ( (node->dy ^ dx) & 0x80000000 )
  199.     {
  200.         // (left is negative)
  201.         return 1;
  202.     }
  203.     return 0;
  204.     }
  205.  
  206.     left = FixedMul ( node->dy>>FRACBITS , dx );
  207.     right = FixedMul ( dy , node->dx>>FRACBITS );
  208.     
  209.     if (right < left)
  210.     {
  211.     // front side
  212.     return 0;
  213.     }
  214.     // back side
  215.     return 1;            
  216. }
  217.  
  218.  
  219. int
  220. R_PointOnSegSide
  221. ( fixed_t    x,
  222.   fixed_t    y,
  223.   seg_t*    line )
  224. {
  225.     fixed_t    lx;
  226.     fixed_t    ly;
  227.     fixed_t    ldx;
  228.     fixed_t    ldy;
  229.     fixed_t    dx;
  230.     fixed_t    dy;
  231.     fixed_t    left;
  232.     fixed_t    right;
  233.     
  234.     lx = line->v1->x;
  235.     ly = line->v1->y;
  236.     
  237.     ldx = line->v2->x - lx;
  238.     ldy = line->v2->y - ly;
  239.     
  240.     if (!ldx)
  241.     {
  242.     if (x <= lx)
  243.         return ldy > 0;
  244.     
  245.     return ldy < 0;
  246.     }
  247.     if (!ldy)
  248.     {
  249.     if (y <= ly)
  250.         return ldx < 0;
  251.     
  252.     return ldx > 0;
  253.     }
  254.     
  255.     dx = (x - lx);
  256.     dy = (y - ly);
  257.     
  258.     // Try to quickly decide by looking at sign bits.
  259.     if ( (ldy ^ ldx ^ dx ^ dy)&0x80000000 )
  260.     {
  261.     if  ( (ldy ^ dx) & 0x80000000 )
  262.     {
  263.         // (left is negative)
  264.         return 1;
  265.     }
  266.     return 0;
  267.     }
  268.  
  269.     left = FixedMul ( ldy>>FRACBITS , dx );
  270.     right = FixedMul ( dy , ldx>>FRACBITS );
  271.     
  272.     if (right < left)
  273.     {
  274.     // front side
  275.     return 0;
  276.     }
  277.     // back side
  278.     return 1;            
  279. }
  280.  
  281.  
  282. //
  283. // R_PointToAngle
  284. // To get a global angle from cartesian coordinates,
  285. //  the coordinates are flipped until they are in
  286. //  the first octant of the coordinate system, then
  287. //  the y (<=x) is scaled and divided by x to get a
  288. //  tangent (slope) value which is looked up in the
  289. //  tantoangle[] table.
  290.  
  291. //
  292.  
  293.  
  294.  
  295.  
  296. angle_t
  297. R_PointToAngle
  298. ( fixed_t    x,
  299.   fixed_t    y )
  300. {    
  301.     x -= viewx;
  302.     y -= viewy;
  303.     
  304.     if ( (!x) && (!y) )
  305.     return 0;
  306.  
  307.     if (x>= 0)
  308.     {
  309.     // x >=0
  310.     if (y>= 0)
  311.     {
  312.         // y>= 0
  313.  
  314.         if (x>y)
  315.         {
  316.         // octant 0
  317.         return tantoangle[ SlopeDiv(y,x)];
  318.         }
  319.         else
  320.         {
  321.         // octant 1
  322.         return ANG90-1-tantoangle[ SlopeDiv(x,y)];
  323.         }
  324.     }
  325.     else
  326.     {
  327.         // y<0
  328.         y = -y;
  329.  
  330.         if (x>y)
  331.         {
  332.         // octant 8
  333.         return -tantoangle[SlopeDiv(y,x)];
  334.         }
  335.         else
  336.         {
  337.         // octant 7
  338.         return ANG270+tantoangle[ SlopeDiv(x,y)];
  339.         }
  340.     }
  341.     }
  342.     else
  343.     {
  344.     // x<0
  345.     x = -x;
  346.  
  347.     if (y>= 0)
  348.     {
  349.         // y>= 0
  350.         if (x>y)
  351.         {
  352.         // octant 3
  353.         return ANG180-1-tantoangle[ SlopeDiv(y,x)];
  354.         }
  355.         else
  356.         {
  357.         // octant 2
  358.         return ANG90+ tantoangle[ SlopeDiv(x,y)];
  359.         }
  360.     }
  361.     else
  362.     {
  363.         // y<0
  364.         y = -y;
  365.  
  366.         if (x>y)
  367.         {
  368.         // octant 4
  369.         return ANG180+tantoangle[ SlopeDiv(y,x)];
  370.         }
  371.         else
  372.         {
  373.          // octant 5
  374.         return ANG270-1-tantoangle[ SlopeDiv(x,y)];
  375.         }
  376.     }
  377.     }
  378.     return 0;
  379. }
  380.  
  381.  
  382. angle_t
  383. R_PointToAngle2
  384. ( fixed_t    x1,
  385.   fixed_t    y1,
  386.   fixed_t    x2,
  387.   fixed_t    y2 )
  388. {    
  389.     viewx = x1;
  390.     viewy = y1;
  391.     
  392.     return R_PointToAngle (x2, y2);
  393. }
  394.  
  395.  
  396. #ifndef AMIGA
  397. fixed_t
  398. R_PointToDist
  399. ( fixed_t    x,
  400.   fixed_t    y )
  401. {
  402.     int        angle;
  403.     fixed_t    dx;
  404.     fixed_t    dy;
  405.     fixed_t    temp;
  406.     fixed_t    dist;
  407.     
  408.     dx = iabs(x - viewx);
  409.     dy = iabs(y - viewy);
  410.     
  411.     if (dy>dx)
  412.     {
  413.     temp = dx;
  414.     dx = dy;
  415.     dy = temp;
  416.     }
  417.     
  418.     angle = (tantoangle[ FixedDiv(dy,dx)>>DBITS ]+ANG90) >> ANGLETOFINESHIFT;
  419.  
  420.     // use as cosine
  421.     dist = FixedDiv (dx, finesine[angle] );    
  422.     
  423.     return dist;
  424. }
  425. #endif
  426.  
  427.  
  428.  
  429. //
  430. // R_InitPointToAngle
  431. //
  432. void R_InitPointToAngle (void)
  433. {
  434.     // UNUSED - now getting from tables.c
  435. #if 0
  436.     int    i;
  437.     long    t;
  438.     float    f;
  439. //
  440. // slope (tangent) to angle lookup
  441. //
  442.     for (i=0 ; i<=SLOPERANGE ; i++)
  443.     {
  444.     f = atan( (float)i/SLOPERANGE )/(3.141592657*2);
  445.     t = 0xffffffff*f;
  446.     tantoangle[i] = t;
  447.     }
  448. #endif
  449. }
  450.  
  451.  
  452. #ifndef AMIGA
  453. //
  454. // R_ScaleFromGlobalAngle
  455. // Returns the texture mapping scale
  456. //  for the current line (horizontal span)
  457. //  at the given angle.
  458. // rw_distance must be calculated first.
  459. //
  460. fixed_t R_ScaleFromGlobalAngle (angle_t visangle)
  461. {
  462.     fixed_t        scale;
  463.     int            anglea;
  464.     int            angleb;
  465.     int            sinea;
  466.     int            sineb;
  467.     fixed_t        num;
  468.     int            den;
  469.  
  470.     // UNUSED
  471. #if 0
  472. {
  473.     fixed_t        dist;
  474.     fixed_t        z;
  475.     fixed_t        sinv;
  476.     fixed_t        cosv;
  477.     
  478.     sinv = finesine[(visangle-rw_normalangle)>>ANGLETOFINESHIFT];    
  479.     dist = FixedDiv (rw_distance, sinv);
  480.     cosv = finecosine[(viewangle-visangle)>>ANGLETOFINESHIFT];
  481.     z = iabs(FixedMul (dist, cosv));
  482.     scale = FixedDiv(projection, z);
  483.     return scale;
  484. }
  485. #endif
  486.  
  487.     anglea = ANG90 + (visangle-viewangle);
  488.     angleb = ANG90 + (visangle-rw_normalangle);
  489.  
  490.     // both sines are allways positive
  491.     sinea = finesine[anglea>>ANGLETOFINESHIFT];    
  492.     sineb = finesine[angleb>>ANGLETOFINESHIFT];
  493.     num = FixedMul(projection,sineb)<<detailshift;
  494.     den = FixedMul(rw_distance,sinea);
  495.  
  496.     if (den > num>>16)
  497.     {
  498.     scale = FixedDiv (num, den);
  499.  
  500.     if (scale > 64*FRACUNIT)
  501.         scale = 64*FRACUNIT;
  502.     else if (scale < 256)
  503.         scale = 256;
  504.     }
  505.     else
  506.     scale = 64*FRACUNIT;
  507.     
  508.     return scale;
  509. }
  510. #endif
  511.  
  512.  
  513.  
  514. //
  515. // R_InitTables
  516. //
  517. void R_InitTables (void)
  518. {
  519.     // UNUSED: now getting from tables.c
  520. #if 0
  521.     int        i;
  522.     float    a;
  523.     float    fv;
  524.     int        t;
  525.     
  526.     // viewangle tangent table
  527.     for (i=0 ; i<FINEANGLES/2 ; i++)
  528.     {
  529.     a = (i-FINEANGLES/4+0.5)*PI*2/FINEANGLES;
  530.     fv = FRACUNIT*tan (a);
  531.     t = fv;
  532.     finetangent[i] = t;
  533.     }
  534.     
  535.     // finesine table
  536.     for (i=0 ; i<5*FINEANGLES/4 ; i++)
  537.     {
  538.     // OPTIMIZE: mirror...
  539.     a = (i+0.5)*PI*2/FINEANGLES;
  540.     t = FRACUNIT*sin (a);
  541.     finesine[i] = t;
  542.     }
  543. #endif
  544.  
  545. }
  546.  
  547.  
  548.  
  549. //
  550. // R_InitTextureMapping
  551. //
  552. void R_InitTextureMapping (void)
  553. {
  554.     int            i;
  555.     int            x;
  556.     int            t;
  557.     fixed_t        focallength;
  558.     
  559.     // Use tangent table to generate viewangletox:
  560.     //  viewangletox will give the next greatest x
  561.     //  after the view angle.
  562.     //
  563.     // Calc focallength
  564.     //  so FIELDOFVIEW angles covers SCREENWIDTH.
  565.     focallength = FixedDiv (centerxfrac,
  566.                 finetangent[FINEANGLES/4+FIELDOFVIEW/2] );
  567.     
  568.     for (i=0 ; i<FINEANGLES/2 ; i++)
  569.     {
  570.     if (finetangent[i] > FRACUNIT*2)
  571.         t = -1;
  572.     else if (finetangent[i] < -FRACUNIT*2)
  573.         t = viewwidth+1;
  574.     else
  575.     {
  576.         t = FixedMul (finetangent[i], focallength);
  577.         t = (centerxfrac - t+FRACUNIT-1)>>FRACBITS;
  578.  
  579.         if (t < -1)
  580.         t = -1;
  581.         else if (t>viewwidth+1)
  582.         t = viewwidth+1;
  583.     }
  584.     viewangletox[i] = t;
  585.     }
  586.     
  587.     // Scan viewangletox[] to generate xtoviewangle[]:
  588.     //  xtoviewangle will give the smallest view angle
  589.     //  that maps to x.    
  590.     for (x=0;x<=viewwidth;x++)
  591.     {
  592.     i = 0;
  593.     while (viewangletox[i]>x)
  594.         i++;
  595.     xtoviewangle[x] = (i<<ANGLETOFINESHIFT)-ANG90;
  596.     }
  597.     
  598.     // Take out the fencepost cases from viewangletox.
  599.     for (i=0 ; i<FINEANGLES/2 ; i++)
  600.     {
  601.     t = FixedMul (finetangent[i], focallength);
  602.     t = centerx - t;
  603.     
  604.     if (viewangletox[i] == -1)
  605.         viewangletox[i] = 0;
  606.     else if (viewangletox[i] == viewwidth+1)
  607.         viewangletox[i]  = viewwidth;
  608.     }
  609.     
  610.     clipangle = xtoviewangle[0];
  611. }
  612.  
  613.  
  614.  
  615. //
  616. // R_InitLightTables
  617. // Only inits the zlight table,
  618. //  because the scalelight table changes with view size.
  619. //
  620. #define DISTMAP        2
  621.  
  622. void R_InitLightTables (void)
  623. {
  624.     int        i;
  625.     int        j;
  626.     int        level;
  627.     int        startmap;     
  628.     int        scale;
  629.     
  630.     // Calculate the light levels to use
  631.     //  for each level / distance combination.
  632.     for (i=0 ; i< LIGHTLEVELS ; i++)
  633.     {
  634.     startmap = ((LIGHTLEVELS-1-i)*2)*NUMCOLORMAPS/LIGHTLEVELS;
  635.     for (j=0 ; j<MAXLIGHTZ ; j++)
  636.     {
  637. //        scale = FixedDiv ((SCREENWIDTH/2*FRACUNIT), (j+1)<<LIGHTZSHIFT);
  638.         scale = FixedDiv ((320/2*FRACUNIT), (j+1)<<LIGHTZSHIFT);
  639.         scale >>= LIGHTSCALESHIFT;
  640.         level = startmap - scale/DISTMAP;
  641.         
  642.         if (level < 0)
  643.         level = 0;
  644.  
  645.         if (level >= NUMCOLORMAPS)
  646.         level = NUMCOLORMAPS-1;
  647.  
  648.         zlight[i][j] = colormaps + level*256;
  649.     }
  650.     }
  651. }
  652.  
  653.  
  654.  
  655. //
  656. // R_SetViewSize
  657. // Do not really change anything here,
  658. //  because it might be in the middle of a refresh.
  659. // The change will take effect next refresh.
  660. //
  661. boolean        setsizeneeded;
  662. int        setblocks;
  663. int        setdetail;
  664.  
  665.  
  666. void
  667. R_SetViewSize
  668. ( int        blocks,
  669.   int        detail )
  670. {
  671.     setsizeneeded = true;
  672.     setblocks = blocks;
  673.     setdetail = detail;
  674. }
  675.  
  676. extern int cpu_type;
  677.  
  678. //
  679. // R_ExecuteSetViewSize
  680. //
  681. void R_ExecuteSetViewSize (void)
  682. {
  683.     fixed_t    cosadj;
  684.     fixed_t    dy;
  685.     int        i;
  686.     int        j;
  687.     int        level;
  688.     int        startmap;     
  689.  
  690.     setsizeneeded = false;
  691.  
  692.     if (setblocks == 11)
  693.     {
  694.     scaledviewwidth = SCREENWIDTH;
  695.     viewheight = SCREENHEIGHT;
  696.     }
  697.     else
  698.     {
  699. //    scaledviewwidth = setblocks*32;
  700. //    viewheight = (setblocks*168/10)&~7;
  701.     scaledviewwidth = (setblocks*SCREENWIDTH/10)&~7;
  702.     viewheight = (setblocks*(SCREENHEIGHT-ST_HEIGHT)/10)&~7;
  703.     }
  704.     
  705.     detailshift = setdetail;
  706.     viewwidth = scaledviewwidth>>detailshift;
  707.     
  708.     centery = viewheight/2;
  709.     centerx = viewwidth/2;
  710.     centerxfrac = centerx<<FRACBITS;
  711.     centeryfrac = centery<<FRACBITS;
  712.     projection = centerxfrac;
  713.  
  714.     if (!detailshift)
  715.     {
  716.     if (cpu_type <= 68040) {
  717.         colfunc = basecolfunc = R_DrawColumn_040;
  718.         spanfunc = R_DrawSpan_040;
  719.     } else {
  720.         colfunc = basecolfunc = R_DrawColumn_060;
  721.         spanfunc = R_DrawSpan_060;
  722.     }
  723. //#ifndef AMIGA
  724.     fuzzcolfunc = R_DrawFuzzColumn;
  725.     transcolfunc = R_DrawTranslatedColumn;
  726. //#endif
  727.     }
  728.     else
  729.     {
  730.     colfunc = basecolfunc = R_DrawColumnLow;
  731. //#ifndef AMIGA
  732.     fuzzcolfunc = R_DrawFuzzColumnLow;
  733.     transcolfunc = R_DrawTranslatedColumnLow;
  734. //#endif
  735.     spanfunc = R_DrawSpanLow;
  736.     }
  737.  
  738.     R_InitBuffer (scaledviewwidth, viewheight);
  739.     
  740.     R_InitTextureMapping ();
  741.     
  742.     // psprite scales
  743. //    pspritescale = FRACUNIT*viewwidth/SCREENWIDTH;
  744. //    pspriteiscale = FRACUNIT*SCREENWIDTH/viewwidth;
  745.     pspritescale = FRACUNIT*viewwidth/320;
  746.     pspriteiscale = FRACUNIT*320/viewwidth;
  747. //    pspritescale2 = FRACUNIT*viewheight/200;
  748.     pspriteiscale2 = FRACUNIT*200/viewheight;
  749.     
  750.     // thing clipping
  751.     for (i=0 ; i<viewwidth ; i++)
  752.     screenheightarray[i] = viewheight;
  753.     
  754.     // planes
  755.     for (i=0 ; i<viewheight ; i++)
  756.     {
  757.     dy = ((i-viewheight/2)<<FRACBITS)+FRACUNIT/2;
  758.     dy = iabs(dy);
  759.     yslope[i] = FixedDiv ( (viewwidth<<detailshift)/2*FRACUNIT, dy);
  760.     }
  761.     
  762.     for (i=0 ; i<viewwidth ; i++)
  763.     {
  764.     cosadj = iabs(finecosine[xtoviewangle[i]>>ANGLETOFINESHIFT]);
  765.     distscale[i] = FixedDiv (FRACUNIT,cosadj);
  766.     }
  767.     
  768.     // Calculate the light levels to use
  769.     //  for each level / scale combination.
  770.     for (i=0 ; i< LIGHTLEVELS ; i++)
  771.     {
  772.     startmap = ((LIGHTLEVELS-1-i)*2)*NUMCOLORMAPS/LIGHTLEVELS;
  773.     for (j=0 ; j<MAXLIGHTSCALE ; j++)
  774.     {
  775.         level = startmap - j*SCREENWIDTH/(viewwidth<<detailshift)/DISTMAP;
  776.         
  777.         if (level < 0)
  778.         level = 0;
  779.  
  780.         if (level >= NUMCOLORMAPS)
  781.         level = NUMCOLORMAPS-1;
  782.  
  783.         scalelight[i][j] = colormaps + level*256;
  784.     }
  785.     }
  786. }
  787.  
  788.  
  789.  
  790. //
  791. // R_Init
  792. //
  793. extern int    detailLevel;
  794. extern int    screenblocks;
  795.  
  796.  
  797.  
  798. void R_Init (void)
  799. {
  800.     R_InitData ();
  801.     printf ("\nR_InitData");
  802.     R_InitPointToAngle ();
  803.     printf ("\nR_InitPointToAngle");
  804.     R_InitTables ();
  805.     // viewwidth / viewheight / detailLevel are set by the defaults
  806.     printf ("\nR_InitTables");
  807.  
  808.     R_SetViewSize (screenblocks, detailLevel);
  809.     R_InitPlanes ();
  810.     printf ("\nR_InitPlanes");
  811.     R_InitLightTables ();
  812.     printf ("\nR_InitLightTables");
  813.     R_InitSkyMap ();
  814.     printf ("\nR_InitSkyMap");
  815.     R_InitTranslationTables ();
  816.     printf ("\nR_InitTranslationsTables");
  817.     
  818.     framecount = 0;
  819. }
  820.  
  821.  
  822. //
  823. // R_PointInSubsector
  824. //
  825. subsector_t*
  826. R_PointInSubsector
  827. ( fixed_t    x,
  828.   fixed_t    y )
  829. {
  830.     node_t*    node;
  831.     int        side;
  832.     int        nodenum;
  833.  
  834.     // single subsector is a special case
  835.     if (!numnodes)                
  836.     return subsectors;
  837.         
  838.     nodenum = numnodes-1;
  839.  
  840.     while (! (nodenum & NF_SUBSECTOR) )
  841.     {
  842.     node = &nodes[nodenum];
  843.     side = R_PointOnSide (x, y, node);
  844.     nodenum = node->children[side];
  845.     }
  846.     
  847.     return &subsectors[nodenum & ~NF_SUBSECTOR];
  848. }
  849.  
  850.  
  851.  
  852. //
  853. // R_SetupFrame
  854. //
  855. void R_SetupFrame (player_t* player)
  856. {        
  857.     int        i;
  858.     
  859.     viewplayer = player;
  860.     viewx = player->mo->x;
  861.     viewy = player->mo->y;
  862.     viewangle = player->mo->angle + viewangleoffset;
  863.     extralight = player->extralight;
  864.  
  865.     viewz = player->viewz;
  866.     
  867.     viewsin = finesine[viewangle>>ANGLETOFINESHIFT];
  868.     viewcos = finecosine[viewangle>>ANGLETOFINESHIFT];
  869.     
  870.     sscount = 0;
  871.     
  872.     if (player->fixedcolormap)
  873.     {
  874.     fixedcolormap =
  875.         colormaps
  876.         + player->fixedcolormap*256*sizeof(lighttable_t);
  877.     
  878.     walllights = scalelightfixed;
  879.  
  880.     for (i=0 ; i<MAXLIGHTSCALE ; i++)
  881.         scalelightfixed[i] = fixedcolormap;
  882.     }
  883.     else
  884.     fixedcolormap = 0;
  885.         
  886.     framecount++;
  887.     validcount++;
  888. }
  889.  
  890.  
  891. //
  892. // R_RenderView
  893. //
  894. void R_RenderPlayerView (player_t* player)
  895. {    
  896.     R_SetupFrame (player);
  897.  
  898.     // Clear buffers.
  899.     R_ClearClipSegs ();
  900.     R_ClearDrawSegs ();
  901.     R_ClearPlanes ();
  902.     R_ClearSprites ();
  903.     
  904.     // check for new console commands.
  905.     NetUpdate ();
  906.  
  907.     // The head node is the last node output.
  908.     R_RenderBSPNode (numnodes-1);
  909.     
  910.     // Check for new console commands.
  911.     NetUpdate ();
  912.     
  913.     R_DrawPlanes ();
  914.     
  915.     // Check for new console commands.
  916.     NetUpdate ();
  917.     
  918.     R_DrawMasked ();
  919.  
  920.     // Check for new console commands.
  921.     NetUpdate ();                
  922. }
  923.